"""
测试XML_Utils中自定义节点的xmlns和值的功能
"""

import tempfile
import os
from com.tools.Xml_Utils.xml_utils import XmlUtils


def test_custom_namespace_functionality():
    """
    测试自定义命名空间功能
    """
    print("测试自定义命名空间功能:")
    
    # 创建临时目录用于测试
    with tempfile.TemporaryDirectory() as temp_dir:
        # 创建空的XML文档
        xml_obj = XmlUtils.create_empty_xml("root")
        
        # 测试添加带自定义命名空间的元素 (xmlns:bean=beantest1)
        print("\n1. 测试添加带自定义命名空间的元素:")
        bean_element = xml_obj.add_element_with_namespace(
            ".", 
            "beanConfig", 
            "bean", 
            "beantest1",
            "Bean配置内容",
            {"id": "bean1"}
        )
        
        if bean_element is not None:
            print("成功添加bean元素")
        else:
            print("添加bean元素失败")
        
        # 验证命名空间是否正确添加
        namespaces = xml_obj.get_namespaces()
        print(f"当前命名空间: {namespaces}")
        assert "bean" in namespaces
        assert namespaces["bean"] == "beantest1"
        
        # 测试添加另一个自定义命名空间 (xmlns:test=testtest1)
        print("\n2. 测试添加另一个自定义命名空间:")
        test_element = xml_obj.add_element_with_namespace(
            ".", 
            "testConfig", 
            "test", 
            "testtest1",
            "测试配置内容",
            {"enabled": "true"}
        )
        
        if test_element is not None:
            print("成功添加test元素")
        else:
            print("添加test元素失败")
        
        # 验证第二个命名空间是否正确添加
        namespaces = xml_obj.get_namespaces()
        print(f"当前命名空间: {namespaces}")
        assert "test" in namespaces
        assert namespaces["test"] == "testtest1"
        
        # 测试为现有元素添加命名空间
        print("\n3. 测试为现有元素添加命名空间:")
        # 先添加一个普通元素
        normal_element = xml_obj.add_element(".", "normalElement", "普通内容")
        
        # 为该元素添加命名空间
        set_namespace_result = xml_obj.set_element_namespace(
            ".//normalElement", 
            "custom", 
            "customuri1"
        )
        
        print(f"为现有元素设置命名空间结果: {set_namespace_result}")
        
        # 验证命名空间是否添加成功
        if set_namespace_result:
            namespaces = xml_obj.get_namespaces()
            print(f"更新后的命名空间: {namespaces}")
            assert "custom" in namespaces
            assert namespaces["custom"] == "customuri1"
        
        # 测试添加多层嵌套的自定义命名空间元素
        print("\n4. 测试添加多层嵌套的自定义命名空间元素:")
        # 在beanConfig下添加子元素
        nested_element = xml_obj.add_element_with_namespace(
            ".//{beantest1}beanConfig", 
            "property", 
            "prop", 
            "propertytest1",
            "属性值",
            {"name": "prop1"}
        )
        
        if nested_element is not None:
            print("成功添加嵌套的命名空间元素")
        else:
            print("添加嵌套的命名空间元素失败")
        
        # 验证嵌套元素的命名空间
        namespaces = xml_obj.get_namespaces()
        print(f"包含嵌套元素后的命名空间: {namespaces}")
        assert "prop" in namespaces
        assert namespaces["prop"] == "propertytest1"
        
        # 测试查找带命名空间的元素
        print("\n5. 测试查找带命名空间的元素:")
        bean_config = xml_obj.find_element(".//{beantest1}beanConfig")
        test_config = xml_obj.find_element(".//{testtest1}testConfig")
        
        print(f"找到beanConfig元素: {bean_config is not None}")
        print(f"找到testConfig元素: {test_config is not None}")
        
        if bean_config is not None:
            bean_text = bean_config.text
            bean_id = bean_config.get("id")
            print(f"beanConfig文本: {bean_text}")
            print(f"beanConfig ID属性: {bean_id}")
            assert bean_text == "Bean配置内容"
            assert bean_id == "bean1"
        
        if test_config is not None:
            test_text = test_config.text
            test_enabled = test_config.get("enabled")
            print(f"testConfig文本: {test_text}")
            print(f"testConfig enabled属性: {test_enabled}")
            assert test_text == "测试配置内容"
            assert test_enabled == "true"
        
        # 测试保存和加载
        print("\n6. 测试保存和加载:")
        xml_file = os.path.join(temp_dir, "custom_namespace_test.xml")
        xml_obj.save_to_file(xml_file, pretty_print=False)  # 避免命名空间问题
        print(f"XML已保存到: {xml_file}")
        
        # 从文件加载
        xml_obj2 = XmlUtils(xml_path=xml_file)
        loaded_bean_text = xml_obj2.get_element_text(".//{beantest1}beanConfig")
        loaded_test_text = xml_obj2.get_element_text(".//{testtest1}testConfig")
        print(f"加载的bean文本: {loaded_bean_text}")
        print(f"加载的test文本: {loaded_test_text}")
        
        # 验证加载的数据
        assert loaded_bean_text == "Bean配置内容"
        assert loaded_test_text == "测试配置内容"
        
        # 测试转换为字符串
        print("\n7. 测试转换为字符串:")
        xml_string = xml_obj.to_string(pretty_print=False)
        print("XML字符串长度:", len(xml_string))
        
        # 验证关键信息在字符串中
        assert "beantest1" in xml_string
        assert "testtest1" in xml_string
        assert "Bean配置内容" in xml_string
        assert "测试配置内容" in xml_string
        
        print("\n所有自定义命名空间功能测试通过!")


def test_multiple_custom_namespaces():
    """
    测试多个自定义命名空间的复杂场景
    """
    print("\n\n测试多个自定义命名空间的复杂场景:")
    
    # 创建复杂的XML结构
    xml_obj = XmlUtils.create_empty_xml("configuration")
    
    # 添加多个不同命名空间的元素
    print("1. 添加多个不同命名空间的元素:")
    
    # 添加数据库配置 (db命名空间)
    db_element = xml_obj.add_element_with_namespace(
        ".", 
        "database", 
        "db", 
        "http://example.com/database",
        None,
        {"version": "1.0"}
    )
    
    # 添加服务器配置 (server命名空间)
    server_element = xml_obj.add_element_with_namespace(
        ".", 
        "server", 
        "srv", 
        "http://example.com/server",
        None,
        {"type": "web"}
    )
    
    # 添加应用配置 (app命名空间)
    app_element = xml_obj.add_element_with_namespace(
        ".", 
        "application", 
        "app", 
        "http://example.com/application",
        "我的应用",
        {"name": "MyApp"}
    )
    
    print("成功添加多个命名空间元素")
    
    # 验证所有命名空间都已注册
    namespaces = xml_obj.get_namespaces()
    print(f"所有命名空间: {namespaces}")
    assert "db" in namespaces
    assert "srv" in namespaces
    assert "app" in namespaces
    assert namespaces["db"] == "http://example.com/database"
    assert namespaces["srv"] == "http://example.com/server"
    assert namespaces["app"] == "http://example.com/application"
    
    # 在各元素下添加子元素
    print("\n2. 在各元素下添加子元素:")
    
    # 在数据库元素下添加连接信息
    xml_obj.add_element_with_namespace(
        ".//{http://example.com/database}database", 
        "connection", 
        "db", 
        "http://example.com/database",
        "localhost:3306",
        {"timeout": "30"}
    )
    
    # 在服务器元素下添加端口信息
    xml_obj.add_element_with_namespace(
        ".//{http://example.com/server}server", 
        "port", 
        "srv", 
        "http://example.com/server",
        "8080",
        {"protocol": "HTTP"}
    )
    
    # 在应用元素下添加版本信息
    xml_obj.add_element_with_namespace(
        ".//{http://example.com/application}application", 
        "version", 
        "app", 
        "http://example.com/application",
        "2.1.0",
        {"release": "stable"}
    )
    
    print("成功添加子元素")
    
    # 测试查找和验证所有元素
    print("\n3. 测试查找和验证所有元素:")
    
    # 查找数据库连接
    connection = xml_obj.get_element_text(".//{http://example.com/database}connection")
    connection_timeout = xml_obj.get_element_attribute(".//{http://example.com/database}connection", "timeout")
    print(f"数据库连接: {connection}, 超时: {connection_timeout}")
    assert connection == "localhost:3306"
    assert connection_timeout == "30"
    
    # 查找服务器端口
    port = xml_obj.get_element_text(".//{http://example.com/server}port")
    port_protocol = xml_obj.get_element_attribute(".//{http://example.com/server}port", "protocol")
    print(f"服务器端口: {port}, 协议: {port_protocol}")
    assert port == "8080"
    assert port_protocol == "HTTP"
    
    # 查找应用版本
    version = xml_obj.get_element_text(".//{http://example.com/application}version")
    version_release = xml_obj.get_element_attribute(".//{http://example.com/application}version", "release")
    app_name = xml_obj.get_element_attribute(".//{http://example.com/application}application", "name")
    app_text = xml_obj.get_element_text(".//{http://example.com/application}application")
    print(f"应用版本: {version}, 发布状态: {version_release}")
    print(f"应用名称: {app_name}, 应用文本: {app_text}")
    assert version == "2.1.0"
    assert version_release == "stable"
    assert app_name == "MyApp"
    assert app_text == "我的应用"
    
    # 测试修改元素
    print("\n4. 测试修改元素:")
    xml_obj.set_element_text(".//{http://example.com/database}connection", "remotehost:5432")
    xml_obj.set_element_attribute(".//{http://example.com/database}connection", "timeout", "60")
    
    # 验证修改结果
    new_connection = xml_obj.get_element_text(".//{http://example.com/database}connection")
    new_timeout = xml_obj.get_element_attribute(".//{http://example.com/database}connection", "timeout")
    print(f"新数据库连接: {new_connection}, 新超时: {new_timeout}")
    assert new_connection == "remotehost:5432"
    assert new_timeout == "60"
    
    print("多个自定义命名空间复杂场景测试通过!")


if __name__ == "__main__":
    test_custom_namespace_functionality()
    test_multiple_custom_namespaces()